
//1. Hello Dart
//// main 的标准写法
//void main(){
//  //注意：Dart 和 Java 一样表达式以分号结尾，写习惯 Kotlin 的小伙伴需要注意了，这可能是你从 Kotlin 转 Dart 最大不适之一。
//  print("Hello World !");
//}

////Dart 中所有函数的类型都是可以省略的，省略的时候返回值类型为 dynamic
//main(){
//  print("Hello World !");
//}

////如果函数内部只有一个表达式，可以省略大括号，使用"=>"箭头函数；
////而对于 Kotlin 则是如果只有一个表达式，可以省略大括号，使用"="连接，类似 fun main(args: Array<String>) = println('Hello World!')
//void main() => print("Hello World !");

//最简写形式
//main() => print("Hello World !");


//2. 数据类型
////在 Dart 中的一切皆是对象，包括数字、布尔值、函数等，它们和 Java 一样都继承于 Object，所以它们的默认值也就是 null。在 Dart 主要有：布尔类型 bool、数字类型 num（数字类型又分为 int、double，并且两者父类都是 num）、字符串类型 String、集合类型（List、Set、Map）、Runes 类和 Symbols 类型（后两个用的并不太多）
//void main(){
//
//  //布尔类型（bool）
//  bool isClosed = true;
//  bool isOpened = false;
//
//  //数字类型（num、int、double）
//  double pi = 3.14;
//  int width = 100;
//  int height = 200;
//  print(width / height);
//  //整除
//  print(width ~/ height);
//  //保留3位小数
//  print(3.1415926.toStringAsFixed(3));
//  //向下取整
//  print(6.6.floor());
//  //向上取整
//  print((-6.6).ceil());
//  print(9.9.ceil());
//  //四舍五入
//  print(66.6.round());
//  //取绝对值
//  print((-66).abs());
//  //转化成 int, toInt、toDouble
//  print(8.7.toInt());
//  //是否是偶数
//  print(3.isEven);
//  //是否是奇数
//  print(5.isEven);
//  //转换为字符串
//  print(66.6.toString());
//}

//3、字符串类型（String）
////在 Dart 中支持单引号、双引号、三引号以及 $ 字符串模板用法
//void main(){
//  //单引号
//  String name = 'Hello Dart!';
//  //双引号
//  String title = "Hello Dart!";
//  //三引号
//  String desc = """
//    Hello Dart,
//
//    Hello ZLC,
//
//    Hello World
//  """;
//  //单值引用
//  num value = 3;
//  String result = "the num is $value";
//  print(result);
//
//  //表达式的值的引用
//  int width = 100;
//  int height = 100;
//  String square = "the square is ${width * height}";
//  print(square);
//
//  String url = "https://mrale.ph/dartvm/";
//
//  //字符串分割 split 方法，类似 Java 和 Kotlin
//  print(url.split("://")[0]);
//
//  //字符串截取 substring 方法，类似 Java 和 Kotlin
//  print(url.substring(3, 9));
//
//  //取当前索引位置字符的 UTF-16 码
//  print(url.codeUnitAt(0));
//
//  //当前字符串是否以指定字符开头，类似 Java 和 Kotlin
//  print(url.startsWith("https"));
//
//  //当前字符串是否以指定字符结尾，类似 Java 和 Kotlin
//  print(url.endsWith("/"));
//
//  //大写，类似 Java 和 Kotlin
//  print(url.toUpperCase());
//
//  //小写，类似 Java 和 Kotlin
//  print(url.toLowerCase());
//
//  //获取指定字符的索引位置，类似 Java 和 Kotlin
//  print(url.indexOf("ph"));
//
//  //字符串是否包含指定字符，类似 Java 和 Kotlin
//  print(url.contains("http"));
//
//  //去除字符串的首尾空格，类似 Java 和 Kotlin
//  print(url.trim());
//
//  //获取字符串长度
//  print(url.length);
//
//  //替换第一次出现 t 字符位置的字符
//  print(url.replaceFirst("t", "A"));
//
//  //全部替换，类似 Java 和 Kotlin
//  print(url.replaceAll("m", "M"));
//}

//4、类型检查（is 和 is!）和强制类型转换（as）
//void main(){
//  int number = 100;
//  double distance = 200.5;
//  num age = 18;
//  print(number is num);//true
//  print(distance is! int);//true
//  print(age as int);//18
//}

//5、Runes 和 Symbols 类型
////Runes 类型是 UTF-32 字节单元定义的 Unicode 字符串，Unicode 可以使用数字表示字母、数字和符号
////在 Dart 中，String 是一系列的 UTF-16 的字节单元，所以想要表示 32 位的 Unicode 的值，就需要用到 Runes 类型。
////一般使用 \uxxxx 这种形式来表示一个 Unicode 码，xxxx 表示 4 个十六进制值
////当十六进制数据多余或者少于 4 位时，将十六进制数放入到花括号中
////Symbols 类型则用得很少，一般用于 Dart 中的反射，但是注意在 Flutter 中禁止使用反射
//void main(){
//  //表示表情符号
//  var clapping = '\u{1f44f}';
//  print(clapping);
//  //返回十六位的字符单元数组
//  print(clapping.codeUnits);
//  print(clapping.runes.toList());
//  Runes input = new Runes(
//      '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');
//  print(new String.fromCharCodes(input));
//}

//6、Object 类型
////在 Dart 中所有东西都是对象，都继承于 Object，所以可以使用 Object 可以定义任何的变量，而且赋值后，类型也可以更改
//void main(){
//  Object color = "block";
//  color = "0xff000000";
//  print(color is String);
//  color = 10;
//  print(color is int);
//}

//7、dynamic 类型
////var 声明的变量未赋值的时候就是 dynamic 类型，它可以像 Object 一样可以改变类型
////dynamic 类型一般用于无法确定具体类型，注意：建议不要滥用 dynamic，一般尽量使用 Object
////Object 和 dynamic 区别在于：Object 会在编译阶段检查类型，而 dynamic 不会在编译阶段检查类型。
//void main(){
//  Object color = "block";
//  color = "0xff000000";
//  print(color is String);
//  color = 10;
//  print(color is int);
//}

//8、var 关键字
////在 Dart 中可以使用 var 来替代具体类型的声明，会自动推导变量的类型，这是因为 var 并不是直接存储值，而是存储值的对象引用，所以 var 可以声明任何变量
////在 Flutter 开发一般会经常使用 var 声明变量，以便于可以自动推导变量的类型。
////如果 var 声明的变量开始不初始化，不仅值可以改变，它的类型也是可以被修改的，但是一旦开始初始化赋值后，它的类型就确定了，后续不能被改变
//void main(){
//  int colorValue = 0xff000000;
//  //var 声明变量自动根据赋值的类型，推导为 String 类型
//  var colorKey = 'black';
//
//
//  var color; // 仅有声明未赋值的时候，这里的 color 的类型是 dynamic,所以它的类型是可以变的
//  color = 'red';
//  print(color is String); //true
//  color = 0xffff0000;
//  print(color is int); //true
//
////  var colorValue = 0xffff0000; //声明时并赋值，这里 colorValue 类型已经推导出为 int，并且确定了类型
////  colorValue = 'red'; //错误，这里会抛出编译异常，String 类型的值不能赋值给 int 类型
////  print(colorValue is int); //true
//}

// 9、常量（final 和 const）
////在 Dart 中声明常量可以使用 const 或 final 两个关键字
////如果常量是编译期就能初始化的就用 const（有点类似 Kotlin 中的 const val），如果常量是运行时期初始化的就用 final（有点类似 Kotlin 中的 val）
//main() {
//  const PI = 3.141592653;//const 定义常量
//  final nowTime = DateTime.now();//final 定义常量
//}

//10、集合 List
//main() {
//  //直接使用 [] 形式初始化
//  List<String> theColorList = ['red', 'yellow', 'blue', 'green'];
//  var myColorList = <String> ['red', 'yellow', 'blue', 'green'];
//  print(theColorList);
//  print(myColorList);
//
//  List<String> colorList = ['red', 'yellow', 'blue', 'green'];
//  //和 Kotlin 类似通过 add 添加一个新的元素
//  colorList.add('white');
//  //可以类似 Kotlin 一样，直接使用数组下标形式访问元素
//  print(colorList[2]);
//  //获取集合的长度，这个 Kotlin 不一样，Kotlin 中使用的是 size
//  print(colorList.length);
//  //在集合指定 index 位置插入指定的元素
//  colorList.insert(1, 'black');
//  //移除集合指定的 index=2 的元素，第 3 个元素
//  colorList.removeAt(2);
//  //截取子集合
//  print(colorList.sublist(1,3));
//  //获取集合中某个范围元素
//  print(colorList.getRange(1, 3));
//  //类似 Kotlin 中的 joinToString 方法，输出：red<--->yellow<--->blue<--->green
//  print(colorList.join('<--->'));
//  print(colorList.isEmpty);
//  print(colorList.contains('green'));
//  //清除所有元素
//  colorList.clear();
//
//  colorList = ['red', 'yellow', 'blue', 'green'];
//  //for-i 遍历
//  for(var i = 0; i < colorList.length; i++) {//可以使用 var 或 int
//    print(colorList[i]);
//  }
//  //forEach 遍历
//  colorList.forEach((color) => print(color));//forEach 的参数为 Function. =>使用了箭头函数
//
//  //for-in 遍历
//  for(var color in colorList) {
//    print(color);
//  }
//
//  //while+iterator 迭代器遍历，类似 Java 中的 iteator
//  while(colorList.iterator.moveNext()) {
//    if(colorList.iterator.current == null){
//      break;
//    }
//    print("color is" + colorList.iterator.current);
//  }
//}

//11、集合 set
//main() {
//  //直接使用 {} 形式初始化
//  List fruitList = ['香蕉','苹果','西瓜','香蕉','苹果','香蕉','苹果'];
//  var fruitSet = new Set();
//  fruitSet.addAll(fruitList);
//
//  print(fruitSet); // 打印结果为：{香蕉, 苹果, 西瓜}
//
//
//  List colorList1 = ['red', 'yellow', 'blue', 'green'];
//  List colorList2 = ['black', 'yellow', 'blue', 'green', 'white'];
//  print(colorList1);
//  print(colorList2);
//  var colorSet1 = new Set();
//  colorSet1.addAll(colorList1);
//  var colorSet2 = new Set();
//  colorSet2.addAll(colorList2);
//  print(colorSet1);
//  print(colorSet2);
//  print(colorSet1.intersection(colorSet2));//交集-->输出: {'yellow', 'blue', 'green'}
//  print(colorSet1.union(colorSet2));//并集--->输出: {'black', 'red', 'yellow', 'blue', 'green', 'white'}
//  print(colorSet1.difference(colorSet2));//补集--->输出: {'red'}

    //遍历出错
//}

//12、集合 Map
//void main(){
//  Map<String, int> colorMap = {'white': 0xffffffff, 'black':0xff000000};//使用 {key:value} 形式初始化
////  var colorMap = <String, int>{'white': 0xffffffff, 'black':0xff000000};
//  print(colorMap);
//
//  print(colorMap.containsKey('green'));//false
//  print(colorMap.containsValue(0xff000000));//true
//  print(colorMap.keys.toList());//['white','black']
//  print(colorMap.values.toList());//[0xffffffff, 0xff000000]
//  colorMap['white'] = 0xfffff000;//修改指定 key 的元素
//  print(colorMap);
////  colorMap.remove('black');//移除指定 key 的元素
////  print(colorMap);
//
//  //遍历
//  colorMap.forEach((key, value) => print('color is $key, color value is $value'));
//
//  //将 List 集合转化成 Map
//  List<String> colorKeys = ['white', 'black'];
//  List<int> colorValues = [0xffffffff, 0xff000000];
//  Map<String, int> colorMaps = Map.fromIterables(colorKeys, colorValues);
//  print(colorMaps);
//
//}

//13、集合常用的操作符
//void main(){
//  List<String> colorList = ['red', 'yellow', 'blue', 'green'];
//  //forEach 箭头函数遍历
//  colorList.forEach((color) => print(color)); //箭头函数遍历，如果箭头函数内部只有一个表达式可以省略大括号
//
//  //map 函数的使用
//  print(colorList.map((color) => '$color').join(","));
//
//  //every 函数的使用，判断里面的元素是否都满足条件，返回值为 true/false
//  print(colorList.every((color) => color == 'red'));
//
//  //sort 函数的使用
//  List<int> numbers = [0, 3, 1, 2, 7, 12, 2, 4];
//  numbers.sort((num1, num2) => num1 - num2); //升序排序
//  numbers.sort((num1, num2) => num2 - num1); //降序排序
//  print(numbers);
//
//  //where 函数使用，相当于 Kotlin 中的 filter 操作符，返回符合条件元素的集合
//  print(numbers.where((num) => num > 6));
//
//  //firstWhere 函数的使用，相当于 Kotlin 中的 find 操作符，返回符合条件的第一个元素，如果没找到返回 null
//  print(numbers.firstWhere((num) => num == 5, orElse: () => -1)); //注意: 如果没有找到，执行 orElse 代码块，可返回一个指定的默认值
//
//  //singleWhere 函数的使用，返回符合条件的第一个元素，如果没找到返回 null，但是前提是集合中只有一个符合条件的元素，否则就会抛出异常
//  print(numbers.singleWhere((num) => num == 4, orElse: () => -1)); //注意：如果没有找到，执行 orElse 代码块，可返回一个指定的默认值
//
//  //take(n)、skip(n) 函数的使用，take(n) 表示取当前集合前 n 个元素，skip(n) 表示跳过前 n 个元素，然后取剩余所有的元素
//  print(numbers.take(5).skip(2));
//
//  //List.from 函数的使用，从给定集合中创建一个新的集合,相当于 clone 一个集合
//  print(List.from(numbers));
//
//  //expand 函数的使用，将集合一个元素扩展成多个元素或者将多个元素组成二维数组展开成平铺一个一位数组
//  var pair = [
//    [1, 2],
//    [3, 4]
//  ];
//  print('flatten list: ${pair.expand((pair) => pair)}');
//
//  var inputs = [1, 2, 3];
//  print('duplicated list: ${inputs.expand((number) =>[
//    number,
//    number,
//    number
//  ])}');
//}

//14、for 循环
//void main(){
//  List<String> colorList = ['red', 'yellow', 'blue', 'green'];
//  for (var i = 0; i < colorList.length; i++) {//可以用 var 或 int
//    print(colorList[i]);
//  }
//}

//15、while 循环
//void main(){
//  List<String> colorList = ['red', 'yellow', 'blue', 'green'];
//  var index = 0;
//  while (index < colorList.length) {
//    print(colorList[index++]);
//  }
//}

//16、do-while 循环
//void main(){
//  List<String> colorList = ['red', 'yellow', 'blue', 'green'];
//  var index = 0;
//  do {
//    print(colorList[index++]);
//  } while (index < colorList.length);
//}


//17、break 和 continue
//void main(){
//  List<String> colorList = ['red', 'yellow', 'blue', 'green'];
//  for (var i = 0; i < colorList.length; i++) {//可以用 var 或 int
//    if(colorList[i] == 'yellow') {
//      continue;
//    }
//    if(colorList[i] == 'blue') {
//      break;
//    }
//    print(colorList[i]);
//  }
//}


//18、if-else
//void main(){
//  var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
//  for (var i = 0; i < numbers.length; i++) {
//    if (numbers[i].isEven) {
//      print('偶数: ${numbers[i]}');
//    } else if (numbers[i].isOdd) {
//      print('奇数: ${numbers[i]}');
//    } else {
//      print('非法数字');
//    }
//  }
//}

//19、三目运算符（?、:）
//void main(){
//  var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
//  for (var i = 0; i < numbers.length; i++) {
//    num targetNumber = numbers[i].isEven ? numbers[i] * 2 : numbers[i] + 4;
//    print(targetNumber);
//  }
//}

//20、switch-case 语句
//void main(){
//  var colorName = "2";
//  var currentColor = "";
//  switch (colorName) {
//    case "read":
//      currentColor = "1";
//      break;
//    case "blue":
//      currentColor = "2";
//      break;
//    case "yellow":
//      currentColor = "3";
//      break;
//  }
//  print(currentColor);
//}


//21、Assert（断言）
//void main(){
//  assert(text != null);//text 为 null，就会中断后续代码执行
//  assert(urlString.startsWith('https'));
//}




